//477. 汉明距离总和

//两个整数的 汉明距离 指的是这两个数字的二进制数对应位不同的数量。
//给你一个整数数组 nums，请你计算并返回 nums 中任意两个数之间 汉明距离的总和 。

//class Solution {
//public:
//    int totalHammingDistance(vector<int>& nums) {
//        int ans = 0, n = nums.size();
//        for (int i = 0; i < 30; ++i) {
//            int c = 0;
//            for (int val : nums) {
//                c += (val >> i) & 1;
//            }
//            ans += c * (n - c);
//        }
//        return ans;
//    }
//};

//1863. 找出所有子集的异或总和再求和

//一个数组的 异或总和 定义为数组中所有元素按位 XOR 的结果；如果数组为 空 ，则异或总和为 0 。
//例如，数组[2, 5, 6] 的 异或总和 为 2 XOR 5 XOR 6 = 1 。
//给你一个数组 nums ，请你求出 nums 中每个 子集 的 异或总和 ，计算并返回这些值相加之 和 。
//注意：在本题中，元素 相同 的不同子集应 多次 计数。
//数组 a 是数组 b 的一个 子集 的前提条件是：从 b 删除几个（也可能不删除）元素能够得到 a 。

//class Solution {
//public:
//    int subsetXORSum(vector<int>& nums) {
//        int or_ = 0;
//        for (int x : nums) {
//            or_ |= x;
//        }
//        return or_ << (nums.size() - 1);
//        //return reduce(nums.begin(), nums.end(), 0, bit_or()) << (nums.size() - 1);
//    }
//};

//2425. 所有数对的异或和

//给你两个下标从 0 开始的数组 nums1 和 nums2 ，两个数组都只包含非负整数。
//请你求出另外一个数组 nums3 ，包含 nums1 和 nums2 中 所有数对 的异或和（nums1 中每个整数都跟 nums2 中每个整数 恰好 匹配一次）。
//请你返回 nums3 中所有整数的 异或和 。

//class Solution {
//public:
//    int xorAllNums(vector<int>& nums1, vector<int>& nums2) {
//        int ans = 0;
//        if (nums1.size() & 1) {
//            for (int i : nums2) {
//                ans ^= i;
//            }
//        }
//        if (nums2.size() & 1) {
//            for (int j : nums1) {
//                ans ^= j;
//            }
//        }
//        return ans;
//    }
//};

//2275. 按位与结果大于零的最长组合

//对数组 nums 执行 按位与 相当于对数组 nums 中的所有整数执行 按位与 。
//例如，对 nums = [1, 5, 3] 来说，按位与等于 1 & 5 & 3 = 1 。
//同样，对 nums = [7] 而言，按位与等于 7 。
//给你一个正整数数组 candidates 。计算 candidates 中的数字每种组合下 按位与 的结果。
//返回按位与结果大于 0 的 最长 组合的长度。

//class Solution {
//public:
//    int largestCombination(vector<int>& candidates) {
//        int cnt[24]{};
//        for (int x : candidates) {
//            for (int i = 0; x; i++) {
//                cnt[i] += x & 1;
//                x >>= 1;
//            }
//        }
//        return ranges::max(cnt);
//    }
//};

//1835. 所有数对按位与结果的异或和

//列表的 异或和（XOR sum）指对所有元素进行按位 XOR 运算的结果。如果列表中仅有一个元素，那么其 异或和 就等于该元素。
//例如，[1, 2, 3, 4] 的 异或和 等于 1 XOR 2 XOR 3 XOR 4 = 4 ，而[3] 的 异或和 等于 3 。
//给你两个下标 从 0 开始 计数的数组 arr1 和 arr2 ，两数组均由非负整数组成。
//根据每个(i, j) 数对，构造一个由 arr1[i] AND arr2[j]（按位 AND 运算）结果组成的列表。其中 0 <= i < arr1.length 且 0 <= j < arr2.length 。
//返回上述列表的 异或和 。

//class Solution {
//public:
//    int getXORSum(vector<int>& arr1, vector<int>& arr2) {
//        int ans = 0, cnt1{}, cnt2{};
//        for (int i = 0; i < 32; i++) {
//            cnt1 = 0;
//            cnt2 = 0;
//            for (int n1 : arr1) {
//                if ((n1 >> i) & 1) {
//                    cnt1++;
//                }
//            }
//            for (int n2 : arr2) {
//                if ((n2 >> i) & 1) {
//                    cnt2++;
//                }
//            }
//            long long total = static_cast<long long>(cnt1) * cnt2;
//            if (total % 2) {
//                ans |= (1 << i);
//            }
//        }
//        return ans;
//    }
//};
//
//class Solution {
//public:
//    int getXORSum(vector<int>& arr1, vector<int>& arr2) {
//        int tot1 = accumulate(arr1.begin(), arr1.end(), 0, bit_xor<int>());
//        int tot2 = accumulate(arr2.begin(), arr2.end(), 0, bit_xor<int>());
//        return tot1 & tot2;
//    }
//};

//3153. 所有数对中数位差之和

//你有一个数组 nums ，它只包含 正 整数，所有正整数的数位长度都 相同 。
//两个整数的 数位差 指的是两个整数 相同 位置上不同数字的数目。
//请你返回 nums 中 所有 整数对里，数位差之和。

//class Solution {
//public:
//    long long sumDigitDifferences(vector<int>& nums) {
//        long long n = nums.size(), m = to_string(nums[0]).length();
//        long long ans = m * n * (n - 1) / 2;
//        vector<array<int, 10>> cnt(m);
//        for (int x : nums) {
//            for (int i = 0; x; x /= 10) {
//                ans -= cnt[i++][x % 10]++;
//            }
//        }
//        return ans;
//    }
//};